跳到主要内容

稠密连接网络（DenseNet）

稠密连接网络（DenseNet）是什么？​

DenseNet（稠密连接网络）是一个深度卷积神经网络架构，由Gao Huang等人在2016年提出。DenseNet的核心思想是确保每一层都可以直接访问前面所有层的特征信息。这是通过将每一层的输出与之前所有层的输出连接起来来实现的，从而形成了稠密连接。这与 ResNet 的跳跃连接不同，因为在DenseNet中，每一层都接收所有前面层的输出作为输入。

上面右图表示 B 的输出在通道维上连接，A 的 output 直接传入 B 后面的层。A 直接与 B 后面的所有层连接在一起，所以叫稠密连接。

DenseNet 的主要优点如下：

  1. 增强特征传播：由于每一层都可以直接访问前面层的输出，这有助于信息和梯度在网络中更容易地流动。

  2. 鼓励特征重用：由于所有层都是连接的，网络可以重用前面层的特征，这有助于减少冗余。

  3. 参数效率更高：由于特征重用，DenseNet通常需要较少的参数来达到与其他网络相同的性能。

DenseNet 的主要组件是稠密块（Dense Block）。在稠密块中，每一层都将其特征与前面所有层的特征连接起来。为了控制特征的数量，DenseNet在稠密块之间使用过渡层，这些层包括卷积和池化操作，以减少特征图的大小。

DenseNet 的数学表示如下：

xl=Hl([x0,x1,...,xl−1])x_{l} = H_{l}([x_{0}, x_{1}, ..., x_{l-1}])

其中，xlx_{l} 是第 ll 层的输出，HlH_{l} 是该层的操作（例如卷积、批量归一化和ReLU），[x0,x1,...,xl−1][x_{0}, x_{1}, ..., x_{l-1}] 表示将前面所有层的输出连接起来。

DenseNet 与 ResNet 的区别​

DenseNet（稠密连接网络）和ResNet（残差网络）都是为了解决深度神经网络中的信息流问题而提出的架构，但它们的方法和核心思想有所不同。以下是DenseNet和ResNet之间的主要区别：

  1. 连接方式：

    • DenseNet：每一层都与前面的所有层连接。这意味着第 ll 层的输入是前 l−1l-1 层的所有输出的集合。
    • ResNet：每一层的输出与其输入相加，形成一个跳跃连接。这种连接通常跨越2层或更多层。

  2. 信息流：

    • DenseNet：由于其稠密连接，信息和梯度可以直接从任何层流到任何其他层，这有助于增强特征传播。
    • ResNet：通过跳跃连接，信息可以“跳过”一层或多层，这有助于解决梯度消失和梯度爆炸问题。

  3. 参数数量和计算效率：

    • DenseNet：由于特征的重用，DenseNet通常更加参数高效。但随着网络深度的增加，特征数量的增长可能会导致计算效率降低。
    • ResNet：虽然它可能需要更多的参数，但由于没有那么多的特征连接，计算效率可能会更高。

  4. 特征重用：

    • DenseNet：稠密连接鼓励特征重用，这有助于减少冗余。
    • ResNet：跳跃连接鼓励网络学习恒等映射，但不像DenseNet那样直接重用特征。

  5. 网络结构：

    • DenseNet：使用稠密块和过渡层。在稠密块中，每一层都与前面的所有层连接。过渡层用于减少特征图的大小。
    • ResNet：使用残差块，其中包含跳跃连接。

  6. 特征图大小：

    • DenseNet：由于每一层都与前面的所有层连接，特征图的数量会随着网络深度的增加而线性增长。
    • ResNet：特征图的数量保持不变，除非进行下采样。

总的来说，DenseNet和ResNet都是为了解决深度神经网络中的信息流问题而提出的，但它们的方法和设计哲学有所不同。选择哪一个取决于特定的应用和需求。

稠密块体的定义​

在 PyTorch 中，稠密块（Dense Block）可以使用 nn.Module 进行定义。稠密块中的每一层都接收前面所有层的输出作为输入。这是通过将前面所有层的输出连接起来来实现的。

以下是一个简单的PyTorch实现，展示了如何定义一个稠密块：

import torch.nn as nn

class DenseLayer(nn.Module):
    def __init__(self, in_channels, growth_rate):
        super(DenseLayer, self).__init__()
        # 定义一个标准的DenseNet的卷积层：BN -> ReLU -> Conv
        self.layer = nn.Sequential(
            nn.BatchNorm2d(in_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels, growth_rate, kernel_size=3, padding=1, bias=False)
        )

    def forward(self, x):
        # 计算卷积层的输出
        out = self.layer(x)
        # 将输出与输入连接起来
        out = torch.cat([x, out], dim=1)
        return out

class DenseBlock(nn.Module):
    def __init__(self, in_channels, growth_rate, num_layers):
        super(DenseBlock, self).__init__()
        # 使用ModuleList来存储所有的DenseLayer
        self.layers = nn.ModuleList()
        for i in range(num_layers):
            # 每次迭代都增加一个DenseLayer，并更新输入通道数
            self.layers.append(DenseLayer(in_channels + i * growth_rate, growth_rate))

    def forward(self, x):
        # 为每个DenseLayer计算输出，并更新x
        for layer in self.layers:
            x = layer(x)
        return x

# 示例：创建一个包含3个层的稠密块，其中输入通道数为64，增长率为32
dense_block = DenseBlock(64, 32, 3)

在上述代码中：

  • DenseLayer 定义了 DenseNet 中的基本卷积层，它包括批量归一化、ReLU激活和3x3卷积。
  • DenseBlock 定义了一个稠密块，它由多个DenseLayer组成。每个DenseLayer的输出都与其输入连接起来，从而形成稠密连接。

增长率（growth_rate）是每个DenseLayer增加的通道数。例如，如果增长率为32，那么每个DenseLayer都会增加32个通道到其输入中。

稠密块组合成 DenseNet 模型​

import torch.nn as nn

class DenseLayer(nn.Module):
    def __init__(self, in_channels, growth_rate):
        super(DenseLayer, self).__init__()
        # 定义一个标准的DenseNet的卷积层：BN -> ReLU -> Conv
        self.layer = nn.Sequential(
            nn.BatchNorm2d(in_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels, growth_rate, kernel_size=3, padding=1, bias=False)
        )

    def forward(self, x):
        # 计算卷积层的输出
        out = self.layer(x)
        # 将输出与输入连接起来
        out = torch.cat([x, out], dim=1)
        return out

class DenseBlock(nn.Module):
    def __init__(self, in_channels, growth_rate, num_layers):
        super(DenseBlock, self).__init__()
        # 使用ModuleList来存储所有的DenseLayer
        self.layers = nn.ModuleList()
        for i in range(num_layers):
            # 每次迭代都增加一个DenseLayer，并更新输入通道数
            self.layers.append(DenseLayer(in_channels + i * growth_rate, growth_rate))

    def forward(self, x):
        # 为每个DenseLayer计算输出，并更新x
        for layer in self.layers:
            x = layer(x)
        return x

class TransitionLayer(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(TransitionLayer, self).__init__()
        # 定义一个过渡层：BN -> ReLU -> Conv -> AvgPool
        self.transition = nn.Sequential(
            nn.BatchNorm2d(in_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),
            nn.AvgPool2d(2, stride=2)
        )

    def forward(self, x):
        return self.transition(x)

class DenseNet(nn.Module):
    def __init__(self, growth_rate, block_config, init_channels=64, num_classes=1000):
        super(DenseNet, self).__init__()
        
        # 初始卷积层
        self.features = nn.Sequential(
            nn.Conv2d(3, init_channels, kernel_size=7, stride=2, padding=3, bias=False),
            nn.BatchNorm2d(init_channels),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        )

        # 添加稠密块和过渡层
        channels = init_channels
        for i, num_layers in enumerate(block_config):
            # 添加稠密块
            self.features.add_module(f'denseblock{i+1}', DenseBlock(channels, growth_rate, num_layers))
            channels += num_layers * growth_rate
            # 添加过渡层（除了最后一个稠密块）
            if i != len(block_config) - 1:
                self.features.add_module(f'transition{i+1}', TransitionLayer(channels, channels // 2))
                channels = channels // 2

        # 全局平均池化和全连接层
        self.features.add_module('bn', nn.BatchNorm2d(channels))
        self.features.add_module('relu', nn.ReLU(inplace=True))
        self.features.add_module('avg_pool', nn.AdaptiveAvgPool2d((1, 1)))

        self.classifier = nn.Linear(channels, num_classes)

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x

# 示例：创建一个简化的DenseNet-121模型
model = DenseNet(growth_rate=32, block_config=[6, 12, 24, 16])

在上述代码中：

  • TransitionLayer 定义了一个过渡层，它用于减少特征图的大小和通道数。
  • DenseNet 类定义了整个DenseNet模型，其中包括初始卷积层、多个稠密块、过渡层、全局平均池化和全连接层。

这个实现是一个简化的 DenseNet-121 模型，其中 block_config=[6, 12, 24, 16] 表示四个稠密块中的层数。

References​

编辑此页
最后由 alsritter.mac 于 更新